nlp_architect.contrib.tensorflow.python.keras.layers.crf.CRF

class nlp_architect.contrib.tensorflow.python.keras.layers.crf.CRF(num_classes, **kwargs)[source]

Conditional Random Field layer (tf.keras) CRF can be used as the last layer in a network (as a classifier). Input shape (features) must be equal to the number of classes the CRF can predict (a linear layer is recommended).

Note: the loss and accuracy functions of networks using CRF must use the provided loss and accuracy functions (denoted as loss and viterbi_accuracy) as the classification of sequences are used with the layers internal weights.

Parameters:num_labels (int) – the number of labels to tag each temporal input.
Input shape:
nD tensor with shape (batch_size, sentence length, num_classes).
Output shape:
nD tensor with shape: (batch_size, sentence length, num_classes).
__init__(num_classes, **kwargs)[source]

Methods

__init__(num_classes, **kwargs)
add_loss(losses[, inputs]) Add loss tensor(s), potentially dependent on layer inputs.
add_update(updates[, inputs]) Add update op(s), potentially dependent on layer inputs.
add_variable(*args, **kwargs) Alias for add_weight.
add_weight(name, shape[, dtype, …]) Adds a new variable to the layer, or gets an existing one; returns it.
apply(inputs, *args, **kwargs) Apply the layer on a input.
build(input_shape) Creates the variables of the layer.
call(inputs[, sequence_lengths]) This is where the layer’s logic lives.
compute_mask(inputs[, mask]) Computes an output mask tensor.
compute_output_shape(input_shape) Computes the output shape of the layer.
count_params() Count the total number of scalars composing the weights.
from_config(config) Creates a layer from its config.
get_config() Returns the config of the layer.
get_input_at(node_index) Retrieves the input tensor(s) of a layer at a given node.
get_input_mask_at(node_index) Retrieves the input mask tensor(s) of a layer at a given node.
get_input_shape_at(node_index) Retrieves the input shape(s) of a layer at a given node.
get_losses_for(inputs) Retrieves losses relevant to a specific set of inputs.
get_output_at(node_index) Retrieves the output tensor(s) of a layer at a given node.
get_output_mask_at(node_index) Retrieves the output mask tensor(s) of a layer at a given node.
get_output_shape_at(node_index) Retrieves the output shape(s) of a layer at a given node.
get_updates_for(inputs) Retrieves updates relevant to a specific set of inputs.
get_weights() Returns the current weights of the layer.
loss(y_true, y_pred)
set_weights(weights) Sets the weights of the layer, from Numpy arrays.

Attributes

activity_regularizer Optional regularizer function for the output of this layer.
dtype
inbound_nodes Deprecated, do NOT use! Only for compatibility with external Keras.
input Retrieves the input tensor(s) of a layer.
input_mask Retrieves the input mask tensor(s) of a layer.
input_shape Retrieves the input shape(s) of a layer.
losses Losses which are associated with this Layer.
name
non_trainable_variables
non_trainable_weights
outbound_nodes Deprecated, do NOT use! Only for compatibility with external Keras.
output Retrieves the output tensor(s) of a layer.
output_mask Retrieves the output mask tensor(s) of a layer.
output_shape Retrieves the output shape(s) of a layer.
trainable_variables
trainable_weights
updates
variables Returns the list of all layer variables/weights.
viterbi_accuracy
weights Returns the list of all layer variables/weights.
activity_regularizer

Optional regularizer function for the output of this layer.

add_loss(losses, inputs=None)

Add loss tensor(s), potentially dependent on layer inputs.

Some losses (for instance, activity regularization losses) may be dependent on the inputs passed when calling a layer. Hence, when reusing the same layer on different inputs a and b, some entries in layer.losses may be dependent on a and some on b. This method automatically keeps track of dependencies.

The get_losses_for method allows to retrieve the losses relevant to a specific set of inputs.

Note that add_loss is not supported when executing eagerly. Instead, variable regularizers may be added through add_variable. Activity regularization is not supported directly (but such losses may be returned from Layer.call()).

Parameters:
  • losses – Loss tensor, or list/tuple of tensors. Rather than tensors, losses may also be zero-argument callables which create a loss tensor. Only callable losses are supported when executing eagerly.
  • inputs – If anything other than None is passed, it signals the losses are conditional on some of the layer’s inputs, and thus they should only be run where these inputs are available. This is the case for activity regularization losses, for instance. If None is passed, the losses are assumed to be unconditional, and will apply across all dataflows of the layer (e.g. weight regularization losses).
Raises:

RuntimeError – If called in Eager mode with a Tensor rather than a callable, or if inputs is not None.

add_update(updates, inputs=None)

Add update op(s), potentially dependent on layer inputs.

Weight updates (for instance, the updates of the moving mean and variance in a BatchNormalization layer) may be dependent on the inputs passed when calling a layer. Hence, when reusing the same layer on different inputs a and b, some entries in layer.updates may be dependent on a and some on b. This method automatically keeps track of dependencies.

The get_updates_for method allows to retrieve the updates relevant to a specific set of inputs.

This call is ignored when eager execution is enabled (in that case, variable updates are run on the fly and thus do not need to be tracked for later execution).

Parameters:
  • updates – Update op, or list/tuple of update ops.
  • inputs – If anything other than None is passed, it signals the updates are conditional on some of the layer’s inputs, and thus they should only be run where these inputs are available. This is the case for BatchNormalization updates, for instance. If None, the updates will be taken into account unconditionally, and you are responsible for making sure that any dependency they might have is available at runtime. A step counter might fall into this category.
add_variable(*args, **kwargs)

Alias for add_weight.

add_weight(name, shape, dtype=None, initializer=None, regularizer=None, trainable=None, constraint=None, partitioner=None, use_resource=None, synchronization=<VariableSynchronization.AUTO: 0>, aggregation=<VariableAggregation.NONE: 0>, **kwargs)

Adds a new variable to the layer, or gets an existing one; returns it.

Parameters:
  • name – variable name.
  • shape – variable shape.
  • dtype – The type of the variable. Defaults to self.dtype or float32.
  • initializer – initializer instance (callable).
  • regularizer – regularizer instance (callable).
  • trainable – whether the variable should be part of the layer’s “trainable_variables” (e.g. variables, biases) or “non_trainable_variables” (e.g. BatchNorm mean, stddev). Note, if the current variable scope is marked as non-trainable then this parameter is ignored and any added variables are also marked as non-trainable. trainable defaults to True unless synchronization is set to ON_READ.
  • constraint – constraint instance (callable).
  • partitioner – Partitioner to be passed to the Checkpointable API.
  • use_resource – Whether to use ResourceVariable.
  • synchronization – Indicates when a distributed a variable will be aggregated. Accepted values are constants defined in the class tf.VariableSynchronization. By default the synchronization is set to AUTO and the current DistributionStrategy chooses when to synchronize. If synchronization is set to ON_READ, trainable must not be set to True.
  • aggregation – Indicates how a distributed variable will be aggregated. Accepted values are constants defined in the class tf.VariableAggregation.
  • **kwargs – Additional keyword arguments. Accepted values are getter and collections.
Returns:

The created variable. Usually either a Variable or ResourceVariable instance. If partitioner is not None, a PartitionedVariable instance is returned.

Raises:
  • RuntimeError – If called with partioned variable regularization and eager execution is enabled.
  • ValueError – When giving unsupported dtype and no initializer or when trainable has been set to True with synchronization set as ON_READ.
apply(inputs, *args, **kwargs)

Apply the layer on a input.

This simply wraps self.__call__.

Parameters:
  • inputs – Input tensor(s).
  • *args – additional positional arguments to be passed to self.call.
  • **kwargs – additional keyword arguments to be passed to self.call.
Returns:

Output tensor(s).

build(input_shape)[source]

Creates the variables of the layer.

call(inputs, sequence_lengths=None, **kwargs)[source]

This is where the layer’s logic lives.

Parameters:
  • inputs – Input tensor, or list/tuple of input tensors.
  • **kwargs – Additional keyword arguments.
Returns:

A tensor or list/tuple of tensors.

compute_mask(inputs, mask=None)

Computes an output mask tensor.

Parameters:
  • inputs – Tensor or list of tensors.
  • mask – Tensor or list of tensors.
Returns:

None or a tensor (or list of tensors,

one per output tensor of the layer).

compute_output_shape(input_shape)[source]

Computes the output shape of the layer.

Assumes that the layer will be built to match that input shape provided.

Parameters:input_shape – Shape tuple (tuple of integers) or list of shape tuples (one per output tensor of the layer). Shape tuples can include None for free dimensions, instead of an integer.
Returns:An input shape tuple.
count_params()

Count the total number of scalars composing the weights.

Returns:An integer count.
Raises:ValueError – if the layer isn’t yet built (in which case its weights aren’t yet defined).
dtype
classmethod from_config(config)

Creates a layer from its config.

This method is the reverse of get_config, capable of instantiating the same layer from the config dictionary. It does not handle layer connectivity (handled by Network), nor weights (handled by set_weights).

Parameters:config – A Python dictionary, typically the output of get_config.
Returns:A layer instance.
get_config()[source]

Returns the config of the layer.

A layer config is a Python dictionary (serializable) containing the configuration of a layer. The same layer can be reinstantiated later (without its trained weights) from this configuration.

The config of a layer does not include connectivity information, nor the layer class name. These are handled by Network (one layer of abstraction above).

Returns:Python dictionary.
get_input_at(node_index)

Retrieves the input tensor(s) of a layer at a given node.

Parameters:node_index – Integer, index of the node from which to retrieve the attribute. E.g. node_index=0 will correspond to the first time the layer was called.
Returns:A tensor (or list of tensors if the layer has multiple inputs).
Raises:RuntimeError – If called in Eager mode.
get_input_mask_at(node_index)

Retrieves the input mask tensor(s) of a layer at a given node.

Parameters:node_index – Integer, index of the node from which to retrieve the attribute. E.g. node_index=0 will correspond to the first time the layer was called.
Returns:A mask tensor (or list of tensors if the layer has multiple inputs).
get_input_shape_at(node_index)

Retrieves the input shape(s) of a layer at a given node.

Parameters:node_index – Integer, index of the node from which to retrieve the attribute. E.g. node_index=0 will correspond to the first time the layer was called.
Returns:A shape tuple (or list of shape tuples if the layer has multiple inputs).
Raises:RuntimeError – If called in Eager mode.
get_losses_for(inputs)

Retrieves losses relevant to a specific set of inputs.

Parameters:inputs – Input tensor or list/tuple of input tensors.
Returns:List of loss tensors of the layer that depend on inputs.
Raises:RuntimeError – If called in Eager mode.
get_output_at(node_index)

Retrieves the output tensor(s) of a layer at a given node.

Parameters:node_index – Integer, index of the node from which to retrieve the attribute. E.g. node_index=0 will correspond to the first time the layer was called.
Returns:A tensor (or list of tensors if the layer has multiple outputs).
Raises:RuntimeError – If called in Eager mode.
get_output_mask_at(node_index)

Retrieves the output mask tensor(s) of a layer at a given node.

Parameters:node_index – Integer, index of the node from which to retrieve the attribute. E.g. node_index=0 will correspond to the first time the layer was called.
Returns:A mask tensor (or list of tensors if the layer has multiple outputs).
get_output_shape_at(node_index)

Retrieves the output shape(s) of a layer at a given node.

Parameters:node_index – Integer, index of the node from which to retrieve the attribute. E.g. node_index=0 will correspond to the first time the layer was called.
Returns:A shape tuple (or list of shape tuples if the layer has multiple outputs).
Raises:RuntimeError – If called in Eager mode.
get_updates_for(inputs)

Retrieves updates relevant to a specific set of inputs.

Parameters:inputs – Input tensor or list/tuple of input tensors.
Returns:List of update ops of the layer that depend on inputs.
Raises:RuntimeError – If called in Eager mode.
get_weights()

Returns the current weights of the layer.

Returns:Weights values as a list of numpy arrays.
inbound_nodes

Deprecated, do NOT use! Only for compatibility with external Keras.

input

Retrieves the input tensor(s) of a layer.

Only applicable if the layer has exactly one input, i.e. if it is connected to one incoming layer.

Returns:

Input tensor or list of input tensors.

Raises:
  • AttributeError – if the layer is connected to
  • more than one incoming layers.
Raises:
input_mask

Retrieves the input mask tensor(s) of a layer.

Only applicable if the layer has exactly one inbound node, i.e. if it is connected to one incoming layer.

Returns:

Input mask tensor (potentially None) or list of input mask tensors.

Raises:
  • AttributeError – if the layer is connected to
  • more than one incoming layers.
input_shape

Retrieves the input shape(s) of a layer.

Only applicable if the layer has exactly one input, i.e. if it is connected to one incoming layer, or if all inputs have the same shape.

Returns:

Input shape, as an integer shape tuple (or list of shape tuples, one tuple per input tensor).

Raises:
loss(y_true, y_pred)[source]
losses

Losses which are associated with this Layer.

Variable regularization tensors are created when this property is accessed, so it is eager safe: accessing losses under a tf.GradientTape will propagate gradients back to the corresponding variables.

Returns:A list of tensors.
name
non_trainable_variables
non_trainable_weights
outbound_nodes

Deprecated, do NOT use! Only for compatibility with external Keras.

output

Retrieves the output tensor(s) of a layer.

Only applicable if the layer has exactly one output, i.e. if it is connected to one incoming layer.

Returns:

Output tensor or list of output tensors.

Raises:
output_mask

Retrieves the output mask tensor(s) of a layer.

Only applicable if the layer has exactly one inbound node, i.e. if it is connected to one incoming layer.

Returns:

Output mask tensor (potentially None) or list of output mask tensors.

Raises:
  • AttributeError – if the layer is connected to
  • more than one incoming layers.
output_shape

Retrieves the output shape(s) of a layer.

Only applicable if the layer has one output, or if all outputs have the same shape.

Returns:

Output shape, as an integer shape tuple (or list of shape tuples, one tuple per output tensor).

Raises:
set_weights(weights)

Sets the weights of the layer, from Numpy arrays.

Parameters:weights – a list of Numpy arrays. The number of arrays and their shape must match number of the dimensions of the weights of the layer (i.e. it should match the output of get_weights).
Raises:ValueError – If the provided weights list does not match the layer’s specifications.
trainable_variables
trainable_weights
updates
variables

Returns the list of all layer variables/weights.

Returns:A list of variables.
viterbi_accuracy
weights

Returns the list of all layer variables/weights.

Returns:A list of variables.